Skip to content

Commit 308b8c0

Browse files
raphael-goetzraphael-goetz
committed
feat: adjusted cli to latest data type defintions
1 parent f987e21 commit 308b8c0

4 files changed

Lines changed: 47 additions & 257 deletions

File tree

‎crates/cli/src/analyser/data_type.rs‎

Lines changed: 21 additions & 140 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
use crate::analyser::core::{AnalysableDataType, Analyser};
22
use crate::diagnostics::diagnose::Diagnose;
33
use crate::diagnostics::kinds::DiagnosticKind;
4-
use tucana::shared::DataTypeIdentifier;
5-
use tucana::shared::data_type_identifier::Type;
64
use tucana::shared::definition_data_type_rule::Config;
75

86
impl Analyser {
@@ -17,13 +15,16 @@ impl Analyser {
1715
},
1816
));
1917
}
20-
21-
if dt.variant == 0 {
22-
self.reporter.add(Diagnose::new(
23-
dt.identifier.clone(),
24-
adt.original_definition.clone(),
25-
DiagnosticKind::ForbiddenVariant,
26-
));
18+
for linked in dt.linked_data_type_identifiers.clone() {
19+
if !self.data_type_identifier_exists(linked.as_str(), None) {
20+
self.reporter.add(Diagnose::new(
21+
dt.identifier.clone(),
22+
adt.original_definition.clone(),
23+
DiagnosticKind::UndefinedDataTypeIdentifier {
24+
identifier: linked.clone(),
25+
},
26+
));
27+
}
2728
}
2829

2930
if dt.alias.is_empty() {
@@ -45,89 +46,27 @@ impl Analyser {
4546
},
4647
));
4748
}
48-
let mut detected: Vec<String> = vec![];
49+
50+
if dt.signature == "" {
51+
self.reporter.add(Diagnose::new(
52+
dt.identifier.clone(),
53+
adt.original_definition.clone(),
54+
DiagnosticKind::NullField {
55+
field_name: "signature".into(),
56+
},
57+
));
58+
}
59+
4960
for optional_rule in &dt.rules {
5061
if let Some(config) = &optional_rule.config {
5162
match config {
52-
Config::ContainsKey(rule) => {
53-
if let Some(dti) = &rule.data_type_identifier {
54-
self.walk_data_type_identifier(adt, dti, &mut detected);
55-
} else {
56-
self.null_field("definition_data_type_contains_key_rule".into(), adt);
57-
}
58-
}
59-
Config::ContainsType(rule) => {
60-
if let Some(dti) = &rule.data_type_identifier {
61-
self.walk_data_type_identifier(adt, dti, &mut detected);
62-
} else {
63-
self.null_field("definition_data_type_contains_type_rule".into(), adt);
64-
}
65-
}
66-
Config::ItemOfCollection(rule) => {
67-
if rule.items.is_empty() {
68-
self.null_field(
69-
"definition_data_type_item_of_collection_rule".into(),
70-
adt,
71-
);
72-
}
73-
}
7463
Config::NumberRange(_) | Config::Regex(_) => {}
75-
Config::InputTypes(rule) => {
76-
if rule.input_types.is_empty() {
77-
self.null_field("definition_data_type_input_types_rule".into(), adt);
78-
}
79-
for input in &rule.input_types {
80-
if let Some(dti) = &input.data_type_identifier {
81-
self.walk_data_type_identifier(adt, dti, &mut detected);
82-
} else {
83-
self.reporter.add(Diagnose::new(
84-
dt.identifier.clone(),
85-
adt.original_definition.clone(),
86-
DiagnosticKind::UndefinedDataTypeIdentifier {
87-
identifier: dt.identifier.clone(),
88-
},
89-
));
90-
}
91-
}
92-
}
93-
Config::ReturnType(rule) => {
94-
if let Some(dti) = &rule.data_type_identifier {
95-
self.walk_data_type_identifier(adt, dti, &mut detected);
96-
} else {
97-
self.null_field("definition_data_type_return_type_rule".into(), adt);
98-
}
99-
}
100-
Config::ParentType(rule) => {
101-
if let Some(dti) = &rule.parent_type {
102-
self.walk_data_type_identifier(adt, dti, &mut detected);
103-
} else {
104-
self.null_field("definition_data_type_parent_type_rule".into(), adt);
105-
}
106-
}
10764
}
10865
} else {
10966
self.null_field("rule".into(), adt);
11067
}
11168
}
11269

113-
for key in dt.generic_keys.iter().filter(|k| !detected.contains(k)) {
114-
self.reporter.add(Diagnose::new(
115-
dt.identifier.clone(),
116-
adt.original_definition.clone(),
117-
DiagnosticKind::UnusedGenericKey { key: key.clone() },
118-
));
119-
}
120-
for key in detected
121-
.into_iter()
122-
.filter(|k| !dt.generic_keys.contains(k))
123-
{
124-
self.reporter.add(Diagnose::new(
125-
dt.identifier.clone(),
126-
adt.original_definition.clone(),
127-
DiagnosticKind::UndefinedGenericKey { key },
128-
));
129-
}
130-
13170
if dt.name.is_empty() {
13271
self.reporter.add(Diagnose::new(
13372
dt.identifier.clone(),
@@ -138,62 +77,4 @@ impl Analyser {
13877
));
13978
}
14079
}
141-
142-
fn walk_data_type_identifier(
143-
&mut self,
144-
adt: &AnalysableDataType,
145-
dti: &DataTypeIdentifier,
146-
acc: &mut Vec<String>,
147-
) {
148-
if let Some(t) = &dti.r#type {
149-
match t {
150-
Type::DataTypeIdentifier(identifier) => {
151-
if !self.data_type_identifier_exists(identifier, Some(adt.id)) {
152-
self.reporter.add(Diagnose::new(
153-
adt.definition_data_type.identifier.clone(),
154-
adt.original_definition.clone(),
155-
DiagnosticKind::UndefinedDataTypeIdentifier {
156-
identifier: identifier.clone(),
157-
},
158-
));
159-
}
160-
}
161-
Type::GenericType(generic) => {
162-
if !self
163-
.data_type_identifier_exists(&generic.data_type_identifier, Some(adt.id))
164-
{
165-
self.reporter.add(Diagnose::new(
166-
adt.definition_data_type.identifier.clone(),
167-
adt.original_definition.clone(),
168-
DiagnosticKind::UndefinedDataTypeIdentifier {
169-
identifier: generic.data_type_identifier.clone(),
170-
},
171-
));
172-
}
173-
if generic.generic_mappers.is_empty() {
174-
self.reporter.add(Diagnose::new(
175-
adt.definition_data_type.identifier.clone(),
176-
adt.original_definition.clone(),
177-
DiagnosticKind::EmptyGenericMapper,
178-
));
179-
}
180-
for mapper in &generic.generic_mappers {
181-
if adt
182-
.definition_data_type
183-
.generic_keys
184-
.contains(&mapper.target)
185-
{
186-
acc.push(mapper.target.clone());
187-
}
188-
for source in &mapper.source {
189-
self.walk_data_type_identifier(adt, source, acc);
190-
}
191-
}
192-
}
193-
Type::GenericKey(key) => acc.push(key.clone()),
194-
}
195-
} else {
196-
self.null_field("data_type".into(), adt);
197-
}
198-
}
19980
}

‎crates/cli/src/analyser/flow_type.rs‎

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -66,24 +66,25 @@ impl Analyser {
6666
}
6767

6868
if let Some(identifier) = &flow.input_type_identifier
69-
&& !self.data_type_identifier_exists(identifier, None)
69+
&& identifier == ""
7070
{
7171
self.reporter.add(Diagnose::new(
7272
name.clone(),
7373
original.clone(),
74-
DiagnosticKind::UndefinedDataTypeIdentifier {
75-
identifier: identifier.clone(),
74+
DiagnosticKind::NullField {
75+
field_name: "input_type_identifier".into(),
7676
},
7777
));
7878
}
79+
7980
if let Some(identifier) = &flow.return_type_identifier
80-
&& !self.data_type_identifier_exists(identifier, None)
81+
&& identifier == ""
8182
{
8283
self.reporter.add(Diagnose::new(
8384
name.clone(),
8485
original.clone(),
85-
DiagnosticKind::UndefinedDataTypeIdentifier {
86-
identifier: identifier.clone(),
86+
DiagnosticKind::NullField {
87+
field_name: "input_type_identifier".into(),
8788
},
8889
));
8990
}

‎crates/cli/src/analyser/function.rs‎

Lines changed: 19 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,25 @@
11
use crate::analyser::core::{AnalysableFunction, Analyser};
22
use crate::diagnostics::diagnose::Diagnose;
33
use crate::diagnostics::kinds::DiagnosticKind;
4-
use tucana::shared::DataTypeIdentifier;
5-
use tucana::shared::data_type_identifier::Type;
64

75
impl Analyser {
86
pub fn analyse_runtime_function(&mut self, af: &AnalysableFunction) {
97
let name = af.function.runtime_name.clone();
108
let function = &af.function;
119
let original = af.original_definition.clone();
1210

11+
for linked in function.linked_data_type_identifiers.clone() {
12+
if !self.data_type_identifier_exists(linked.as_str(), None) {
13+
self.reporter.add(Diagnose::new(
14+
name.clone(),
15+
original.clone(),
16+
DiagnosticKind::UndefinedDataTypeIdentifier {
17+
identifier: linked.clone(),
18+
},
19+
));
20+
}
21+
}
22+
1323
if function.display_icon.is_empty() {
1424
self.reporter.add(Diagnose::new(
1525
name.clone(),
@@ -68,12 +78,13 @@ impl Analyser {
6878
));
6979
}
7080

71-
let mut detected_generic_keys: Vec<String> = vec![];
72-
if let Some(identifier) = &function.return_type_identifier {
73-
detected_generic_keys.append(&mut self.walk_function_dti(
74-
&name,
75-
&original,
76-
identifier.clone(),
81+
if function.signature == "" {
82+
self.reporter.add(Diagnose::new(
83+
name.clone(),
84+
original.clone(),
85+
DiagnosticKind::NullField {
86+
field_name: "signature".into(),
87+
},
7788
));
7889
}
7990

@@ -107,22 +118,6 @@ impl Analyser {
107118
));
108119
}
109120

110-
if let Some(identifier) = &parameter.data_type_identifier {
111-
detected_generic_keys.append(&mut self.walk_function_dti(
112-
&name,
113-
&original,
114-
identifier.clone(),
115-
));
116-
} else {
117-
self.reporter.add(Diagnose::new(
118-
name.clone(),
119-
original.clone(),
120-
DiagnosticKind::NullField {
121-
field_name: "data_type".into(),
122-
},
123-
));
124-
}
125-
126121
if param_names.contains(&parameter.runtime_name) {
127122
self.reporter.add(Diagnose::new(
128123
name.clone(),
@@ -134,85 +129,5 @@ impl Analyser {
134129
}
135130
param_names.push(parameter.runtime_name.clone());
136131
}
137-
138-
for key in function
139-
.generic_keys
140-
.iter()
141-
.filter(|k| !detected_generic_keys.contains(k))
142-
.cloned()
143-
{
144-
self.reporter.add(Diagnose::new(
145-
name.clone(),
146-
original.clone(),
147-
DiagnosticKind::UnusedGenericKey { key },
148-
));
149-
}
150-
for key in detected_generic_keys
151-
.into_iter()
152-
.filter(|k| !function.generic_keys.contains(k))
153-
{
154-
self.reporter.add(Diagnose::new(
155-
name.clone(),
156-
original.clone(),
157-
DiagnosticKind::UndefinedGenericKey { key },
158-
));
159-
}
160-
}
161-
162-
fn walk_function_dti(
163-
&mut self,
164-
name: &str,
165-
original: &crate::parser::Meta,
166-
identifier: DataTypeIdentifier,
167-
) -> Vec<String> {
168-
let mut result: Vec<String> = vec![];
169-
if let Some(t) = identifier.r#type {
170-
match t {
171-
Type::DataTypeIdentifier(dt) => {
172-
if !self.data_type_identifier_exists(&dt, None) {
173-
self.reporter.add(Diagnose::new(
174-
name.to_string(),
175-
original.clone(),
176-
DiagnosticKind::UndefinedDataTypeIdentifier { identifier: dt },
177-
));
178-
}
179-
}
180-
Type::GenericType(gt) => {
181-
if !self.data_type_identifier_exists(&gt.data_type_identifier, None) {
182-
self.reporter.add(Diagnose::new(
183-
name.to_string(),
184-
original.clone(),
185-
DiagnosticKind::UndefinedDataTypeIdentifier {
186-
identifier: gt.data_type_identifier.clone(),
187-
},
188-
));
189-
}
190-
if gt.generic_mappers.is_empty() {
191-
self.reporter.add(Diagnose::new(
192-
name.to_string(),
193-
original.clone(),
194-
DiagnosticKind::EmptyGenericMapper,
195-
));
196-
}
197-
for mapper in &gt.generic_mappers {
198-
for source in mapper.source.clone() {
199-
result.append(&mut self.walk_function_dti(name, original, source));
200-
}
201-
if !self.generic_key_in_target(&mapper.target, &gt.data_type_identifier) {
202-
self.reporter.add(Diagnose::new(
203-
name.to_string(),
204-
original.clone(),
205-
DiagnosticKind::GenericKeyNotInMappingTarget {
206-
key: mapper.target.clone(),
207-
target: gt.data_type_identifier.clone(),
208-
},
209-
));
210-
}
211-
}
212-
}
213-
Type::GenericKey(key) => result.push(key.clone()),
214-
}
215-
}
216-
result
217132
}
218133
}

‎crates/cli/src/analyser/index_identifier.rs‎

Lines changed: 0 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -35,11 +35,4 @@ impl IdentifierIndex {
3535
.map(|found| except.map(|e| *found != e).unwrap_or(true))
3636
.unwrap_or(false)
3737
}
38-
39-
pub fn has_function(&self, name: &str, except: Option<i16>) -> bool {
40-
self.functions
41-
.get(&normalize(name))
42-
.map(|found| except.map(|e| *found != e).unwrap_or(true))
43-
.unwrap_or(false)
44-
}
4538
}

0 commit comments

Comments
 (0)