dsntk_model/
parser.rs

1//! # XML parser for DMN model
2
3use crate::errors::*;
4use crate::model::*;
5use crate::validators::{validate_model, validate_schema};
6use crate::xml_utils::*;
7use dsntk_common::{gen_id, to_uri, HRef, Result, Uri};
8use dsntk_feel::{Name, FEEL_TYPE_NAME_ANY};
9use roxmltree::{Node, NodeType};
10
11/// Parses the XML input document containing DMN model into [Definitions].
12pub fn parse(input: &str) -> Result<Definitions> {
13  // parse document
14  match roxmltree::Document::parse(input) {
15    Ok(document) => {
16      // firstly validate the document against the XML Schema
17      let node = validate_schema(&document)?;
18      // initialize the model parser
19      let mut model_parser = ModelParser::new();
20      // parse the model into definitions
21      let definitions = model_parser.parse_definitions(&node)?;
22      // validate the final model against several rules defined in specification
23      validate_model(definitions)
24    }
25    Err(reason) => Err(err_xml_parsing_model_failed(&reason.to_string())),
26  }
27}
28
29/// XML parser for DMN model.
30pub struct ModelParser {
31  /// Model namespace used in parsed definitions.
32  namespace: String,
33  /// Model name used in parsed definitions.
34  model_name: String,
35}
36
37impl ModelParser {
38  /// Creates new model parser.
39  fn new() -> Self {
40    Self {
41      namespace: "".to_string(),
42      model_name: "".to_string(),
43    }
44  }
45
46  /// Parses model [Definitions].
47  fn parse_definitions(&mut self, node: &Node) -> Result<Definitions> {
48    self.namespace = required_uri(node, ATTR_NAMESPACE)?;
49    self.model_name = required_attribute(node, ATTR_NAME)?;
50    let definitions = Definitions {
51      namespace: self.namespace.clone(),
52      model_name: self.model_name.clone(),
53      name: required_name(node)?,
54      feel_name: required_feel_name(node)?,
55      id: optional_id(node),
56      description: optional_child_optional_content(node, NODE_DESCRIPTION),
57      label: optional_attribute(node, ATTR_LABEL),
58      extension_elements: self.parse_extension_elements(node),
59      extension_attributes: self.parse_extension_attributes(node),
60      expression_language: optional_uri(node, ATTR_EXPRESSION_LANGUAGE)?,
61      type_language: optional_attribute(node, ATTR_TYPE_LANGUAGE),
62      exporter: optional_attribute(node, ATTR_EXPORTER),
63      exporter_version: optional_attribute(node, ATTR_EXPORTER_VERSION),
64      item_definitions: self.parse_item_definition_nodes(node, NODE_ITEM_DEFINITION)?,
65      drg_elements: self.parse_drg_elements(node)?,
66      business_context_elements: self.parse_business_context_elements(node)?,
67      imports: self.parse_imports(node)?,
68      dmndi: self.parse_dmndi(node)?,
69    };
70    Ok(definitions)
71  }
72
73  /// Parses a collection of [ItemDefinition] nodes.
74  fn parse_item_definition_nodes(&mut self, node: &Node, child_name: &str) -> Result<Vec<ItemDefinition>> {
75    let mut items = vec![];
76    for ref child_node in node.children().filter(name_eq(child_name)) {
77      items.push(self.parse_item_definition(child_node)?);
78    }
79    Ok(items)
80  }
81
82  /// Parses a single [ItemDefinition] node.
83  fn parse_item_definition(&mut self, node: &Node) -> Result<ItemDefinition> {
84    let namespace = self.namespace.clone();
85    let model_name = self.model_name.clone();
86    let name = required_name(node)?;
87    let feel_name = required_feel_name(node)?;
88    let id = optional_id(node);
89    let description = optional_child_optional_content(node, NODE_DESCRIPTION);
90    let label = optional_attribute(node, ATTR_LABEL);
91    let extension_elements = self.parse_extension_elements(node);
92    let extension_attributes = self.parse_extension_attributes(node);
93    let type_language = optional_attribute(node, ATTR_TYPE_LANGUAGE);
94    let allowed_values = self.parse_unary_tests(node, NODE_ALLOWED_VALUES)?;
95    let item_components = self.parse_item_definition_nodes(node, NODE_ITEM_COMPONENT)?;
96    let is_collection = self.parse_boolean_attribute(node, ATTR_IS_COLLECTION, false);
97    let function_item = self.parse_function_item(node)?;
98    let mut type_ref = optional_child_required_content(node, NODE_TYPE_REF)?;
99    if type_ref.is_none() && item_components.is_empty() && !is_collection && function_item.is_none() {
100      type_ref = Some(FEEL_TYPE_NAME_ANY.to_string());
101    }
102    Ok(ItemDefinition {
103      namespace,
104      model_name,
105      name,
106      feel_name,
107      id,
108      description,
109      label,
110      extension_elements,
111      extension_attributes,
112      type_ref,
113      type_language,
114      feel_type: None,
115      allowed_values,
116      item_components,
117      is_collection,
118      function_item,
119    })
120  }
121
122  /// Parses optional function item.
123  fn parse_function_item(&self, node: &Node) -> Result<Option<FunctionItem>> {
124    if let Some(ref n) = node.children().find(name_eq(NODE_FUNCTION_ITEM)) {
125      Ok(Some(FunctionItem {
126        output_type_ref: optional_attribute(n, ATTR_OUTPUT_TYPE_REF),
127        parameters: self.parse_vec_information_item_child(n, NODE_PARAMETERS)?,
128      }))
129    } else {
130      Ok(None)
131    }
132  }
133
134  /// Parsers unary tests.
135  fn parse_unary_tests(&self, node: &Node, child_name: &str) -> Result<Option<UnaryTests>> {
136    if let Some(child_node) = node.children().find(name_eq(child_name)) {
137      Ok(Some(UnaryTests {
138        text: optional_child_required_content(&child_node, NODE_TEXT)?,
139        expression_language: optional_attribute(&child_node, ATTR_EXPRESSION_LANGUAGE),
140      }))
141    } else {
142      Ok(None)
143    }
144  }
145
146  /// Parses DRG elements.
147  fn parse_drg_elements(&mut self, node: &Node) -> Result<Vec<DrgElement>> {
148    let mut drg_elements = vec![];
149    drg_elements.append(&mut self.parse_input_data_nodes(node)?);
150    drg_elements.append(&mut self.parse_decision_nodes(node)?);
151    drg_elements.append(&mut self.parse_business_knowledge_model_nodes(node)?);
152    drg_elements.append(&mut self.parse_decision_services(node)?);
153    drg_elements.append(&mut self.parse_knowledge_sources(node)?);
154    Ok(drg_elements)
155  }
156
157  /// Parses `inputData` nodes.
158  fn parse_input_data_nodes(&self, node: &Node) -> Result<Vec<DrgElement>> {
159    let mut input_data_items = vec![];
160    for ref child_node in node.children().filter(name_eq(NODE_INPUT_DATA)) {
161      let name = required_name(child_node)?;
162      let feel_name = required_feel_name(child_node)?;
163      let variable = self
164        .parse_opt_information_item_child(child_node, NODE_VARIABLE)?
165        .unwrap_or(self.create_information_item(name.clone(), feel_name.clone())?);
166      let input_data = InputData {
167        namespace: self.namespace.clone(),
168        model_name: self.model_name.clone(),
169        id: optional_id(child_node),
170        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
171        label: optional_attribute(child_node, ATTR_LABEL),
172        extension_elements: self.parse_extension_elements(child_node),
173        extension_attributes: self.parse_extension_attributes(child_node),
174        name,
175        feel_name,
176        variable,
177      };
178      input_data_items.push(DrgElement::InputData(input_data));
179    }
180    Ok(input_data_items)
181  }
182
183  /// Parses `decision` nodes.
184  fn parse_decision_nodes(&mut self, node: &Node) -> Result<Vec<DrgElement>> {
185    let mut decision_items = vec![];
186    for ref child_node in node.children().filter(name_eq(NODE_DECISION)) {
187      let name = required_name(child_node)?;
188      let feel_name = required_feel_name(child_node)?;
189      let variable = self
190        .parse_opt_information_item_child(child_node, NODE_VARIABLE)?
191        .unwrap_or(self.create_information_item(name.clone(), feel_name.clone())?);
192      let decision = Decision {
193        namespace: self.namespace.clone(),
194        model_name: self.model_name.clone(),
195        name,
196        feel_name,
197        id: optional_id(child_node),
198        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
199        label: optional_attribute(child_node, ATTR_LABEL),
200        extension_elements: self.parse_extension_elements(child_node),
201        extension_attributes: self.parse_extension_attributes(child_node),
202        question: optional_child_optional_content(child_node, NODE_QUESTION),
203        allowed_answers: optional_child_optional_content(child_node, NODE_ALLOWED_ANSWERS),
204        variable,
205        decision_logic: self.parse_optional_child_expression_instance(child_node)?,
206        information_requirements: self.parse_information_requirements(child_node, NODE_INFORMATION_REQUIREMENT)?,
207        knowledge_requirements: self.parse_knowledge_requirements(child_node, NODE_KNOWLEDGE_REQUIREMENT)?,
208        authority_requirements: self.parse_authority_requirements(child_node, NODE_AUTHORITY_REQUIREMENT)?,
209      };
210      decision_items.push(DrgElement::Decision(decision));
211    }
212    Ok(decision_items)
213  }
214
215  /// Parses `businessKnowledgeModel` nodes.
216  fn parse_business_knowledge_model_nodes(&mut self, node: &Node) -> Result<Vec<DrgElement>> {
217    let mut parsed_items = vec![];
218    for ref child_node in node.children().filter(name_eq(NODE_BUSINESS_KNOWLEDGE_MODEL)) {
219      let name = required_name(child_node)?;
220      let feel_name = required_feel_name(child_node)?;
221      let variable = self
222        .parse_opt_information_item_child(child_node, NODE_VARIABLE)?
223        .unwrap_or(self.create_information_item(name.clone(), feel_name.clone())?);
224      let business_knowledge_model = BusinessKnowledgeModel {
225        namespace: self.namespace.clone(),
226        model_name: self.model_name.clone(),
227        name,
228        feel_name,
229        id: optional_id(child_node),
230        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
231        label: optional_attribute(child_node, ATTR_LABEL),
232        extension_elements: self.parse_extension_elements(child_node),
233        extension_attributes: self.parse_extension_attributes(child_node),
234        variable,
235        encapsulated_logic: self.parse_function_definition_child(child_node, NODE_ENCAPSULATED_LOGIC)?,
236        knowledge_requirements: self.parse_knowledge_requirements(child_node, NODE_KNOWLEDGE_REQUIREMENT)?,
237        authority_requirements: self.parse_authority_requirements(child_node, NODE_AUTHORITY_REQUIREMENT)?,
238      };
239      parsed_items.push(DrgElement::BusinessKnowledgeModel(business_knowledge_model));
240    }
241    Ok(parsed_items)
242  }
243
244  /// Parses decision services.
245  fn parse_decision_services(&self, node: &Node) -> Result<Vec<DrgElement>> {
246    let mut drg_elements = vec![];
247    for ref child_node in node.children().filter(name_eq(NODE_DECISION_SERVICE)) {
248      let name = required_name(child_node)?;
249      let feel_name = required_feel_name(child_node)?;
250      let variable = self
251        .parse_opt_information_item_child(child_node, NODE_VARIABLE)?
252        .unwrap_or(self.create_information_item(name.clone(), feel_name.clone())?);
253      let decision_service = DecisionService {
254        namespace: self.namespace.clone(),
255        model_name: self.model_name.clone(),
256        name,
257        feel_name,
258        id: optional_id(child_node),
259        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
260        label: optional_attribute(child_node, ATTR_LABEL),
261        extension_elements: self.parse_extension_elements(child_node),
262        extension_attributes: self.parse_extension_attributes(child_node),
263        variable,
264        output_decisions: self.required_hrefs_in_child_nodes(child_node, NODE_OUTPUT_DECISION)?,
265        encapsulated_decisions: self.required_hrefs_in_child_nodes(child_node, NODE_ENCAPSULATED_DECISION)?,
266        input_decisions: self.required_hrefs_in_child_nodes(child_node, NODE_INPUT_DECISION)?,
267        input_data: self.required_hrefs_in_child_nodes(child_node, NODE_INPUT_DATA)?,
268      };
269      drg_elements.push(DrgElement::DecisionService(decision_service));
270    }
271    Ok(drg_elements)
272  }
273
274  /// Parses knowledge sources.
275  fn parse_knowledge_sources(&mut self, node: &Node) -> Result<Vec<DrgElement>> {
276    let mut drg_elements = vec![];
277    for ref child_node in node.children().filter(name_eq(NODE_KNOWLEDGE_SOURCE)) {
278      let knowledge_source = KnowledgeSource {
279        namespace: self.namespace.clone(),
280        model_name: self.model_name.clone(),
281        id: optional_id(child_node),
282        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
283        label: optional_attribute(child_node, ATTR_LABEL),
284        extension_elements: self.parse_extension_elements(child_node),
285        extension_attributes: self.parse_extension_attributes(child_node),
286        name: required_name(child_node)?,
287        feel_name: required_feel_name(child_node)?,
288        authority_requirements: self.parse_authority_requirements(child_node, NODE_AUTHORITY_REQUIREMENT)?,
289      };
290      drg_elements.push(DrgElement::KnowledgeSource(knowledge_source));
291    }
292    Ok(drg_elements)
293  }
294
295  fn required_hrefs_in_child_nodes(&self, node: &Node, child_name: &str) -> Result<Vec<HRef>> {
296    let mut hrefs = vec![];
297    for ref child_node in node.children().filter(name_eq(child_name)) {
298      let text = required_attribute(child_node, ATTR_HREF)?;
299      let href = HRef::try_from(text.as_str())?;
300      hrefs.push(href);
301    }
302    Ok(hrefs)
303  }
304
305  fn parse_function_definition_child(&self, node: &Node, child_name: &str) -> Result<Option<FunctionDefinition>> {
306    if let Some(child_node) = node.children().find(name_eq(child_name)) {
307      Ok(Some(self.parse_function_definition(&child_node)?))
308    } else {
309      Ok(None)
310    }
311  }
312
313  fn parse_optional_function_definition(&self, node: &Node) -> Result<Option<FunctionDefinition>> {
314    if let Some(child_node) = node.children().find(name_eq(NODE_FUNCTION_DEFINITION)) {
315      Ok(Some(self.parse_function_definition(&child_node)?))
316    } else {
317      Ok(None)
318    }
319  }
320
321  fn parse_function_definition(&self, node: &Node) -> Result<FunctionDefinition> {
322    Ok(FunctionDefinition {
323      namespace: self.namespace.clone(),
324      model_name: self.model_name.clone(),
325      id: optional_id(node),
326      description: optional_child_optional_content(node, NODE_DESCRIPTION),
327      label: optional_attribute(node, ATTR_LABEL),
328      extension_elements: self.parse_extension_elements(node),
329      extension_attributes: self.parse_extension_attributes(node),
330      type_ref: optional_attribute(node, ATTR_TYPE_REF),
331      formal_parameters: self.parse_vec_information_item_child(node, NODE_FORMAL_PARAMETER)?,
332      body: self.parse_optional_child_expression_instance(node)?,
333      kind: self.parse_function_kind(node)?,
334    })
335  }
336
337  fn parse_function_kind(&self, node: &Node) -> Result<FunctionKind> {
338    if let Some(function_kind_text) = optional_attribute(node, ATTR_KIND) {
339      match function_kind_text.trim() {
340        "FEEL" => Ok(FunctionKind::Feel),
341        "Java" => Ok(FunctionKind::Java),
342        "PMML" => Ok(FunctionKind::Pmml),
343        other => Err(err_invalid_function_kind(other)),
344      }
345    } else {
346      Ok(FunctionKind::Feel)
347    }
348  }
349
350  /// Parses business context elements like performance indicators and organisational units.
351  fn parse_business_context_elements(&self, node: &Node) -> Result<Vec<BusinessContextElementInstance>> {
352    let mut business_context_elements = vec![];
353    for ref child_node in node.children().filter(name_eq(NODE_PERFORMANCE_INDICATOR)) {
354      let performance_indicator = PerformanceIndicator {
355        namespace: self.namespace.clone(),
356        model_name: self.model_name.clone(),
357        id: optional_id(child_node),
358        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
359        label: optional_attribute(child_node, ATTR_LABEL),
360        extension_elements: self.parse_extension_elements(child_node),
361        extension_attributes: self.parse_extension_attributes(child_node),
362        name: required_name(child_node)?,
363        feel_name: required_feel_name(child_node)?,
364        uri: optional_attribute(child_node, ATTR_URI),
365        impacting_decisions: optional_children_required_href(child_node, NODE_IMPACTING_DECISION)?,
366      };
367      business_context_elements.push(BusinessContextElementInstance::PerformanceIndicator(performance_indicator));
368    }
369    for ref child_node in node.children().filter(name_eq(NODE_ORGANISATION_UNIT)) {
370      let organisation_unit = OrganizationUnit {
371        namespace: self.namespace.clone(),
372        model_name: self.model_name.clone(),
373        id: optional_id(child_node),
374        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
375        label: optional_attribute(child_node, ATTR_LABEL),
376        extension_elements: self.parse_extension_elements(child_node),
377        extension_attributes: self.parse_extension_attributes(child_node),
378        name: required_name(child_node)?,
379        feel_name: required_feel_name(child_node)?,
380        uri: optional_attribute(child_node, ATTR_URI),
381        decisions_made: optional_children_required_href(child_node, NODE_DECISION_MADE)?,
382        decisions_owned: optional_children_required_href(child_node, NODE_DECISION_OWNED)?,
383      };
384      business_context_elements.push(BusinessContextElementInstance::OrganizationUnit(organisation_unit));
385    }
386    Ok(business_context_elements)
387  }
388
389  /// Parses a collection of [Imports](Import).
390  fn parse_imports(&self, node: &Node) -> Result<Vec<Import>> {
391    let mut imports = vec![];
392    for ref child_node in node.children().filter(name_eq(NODE_IMPORT)) {
393      let import = Import {
394        namespace: required_uri(child_node, ATTR_NAMESPACE)?,
395        model_name: self.model_name.clone(),
396        id: optional_id(child_node),
397        description: optional_child_optional_content(child_node, NODE_DESCRIPTION),
398        label: optional_attribute(child_node, ATTR_LABEL),
399        extension_elements: self.parse_extension_elements(child_node),
400        extension_attributes: self.parse_extension_attributes(child_node),
401        name: required_name(child_node)?,
402        feel_name: required_feel_name(child_node)?,
403        import_type: required_attribute(child_node, ATTR_IMPORT_TYPE)?,
404        location_uri: optional_attribute(child_node, ATTR_LOCATION_URI),
405      };
406      imports.push(import);
407    }
408    Ok(imports)
409  }
410
411  /// Parses a required [InformationItem], contained in a child node having the specified name.
412  fn parse_req_information_item_child(&self, node: &Node, child_name: &str) -> Result<InformationItem> {
413    if let Some(child_node) = node.children().find(name_eq(child_name)) {
414      self.parse_information_item(&child_node)
415    } else {
416      Err(err_xml_expected_mandatory_child_node(&node_name_pos(node), child_name))
417    }
418  }
419
420  /// Parses an optional [InformationItem], contained in a child node having the specified name.
421  fn parse_opt_information_item_child(&self, node: &Node, child_name: &str) -> Result<Option<InformationItem>> {
422    Ok(if let Some(child_node) = node.children().find(name_eq(child_name)) {
423      Some(self.parse_information_item(&child_node)?)
424    } else {
425      None
426    })
427  }
428
429  /// Parses a collection of [InformationItem]s contained in multiple child nodes having the specified name.
430  fn parse_vec_information_item_child(&self, node: &Node, child_name: &str) -> Result<Vec<InformationItem>> {
431    let mut information_items = vec![];
432    for child_node in node.children().filter(name_eq(child_name)) {
433      information_items.push(self.parse_information_item(&child_node)?);
434    }
435    Ok(information_items)
436  }
437
438  /// Parses the attributes of the [InformationItem] element.
439  fn parse_information_item(&self, node: &Node) -> Result<InformationItem> {
440    Ok(InformationItem {
441      namespace: self.namespace.clone(),
442      model_name: self.model_name.clone(),
443      id: optional_id(node),
444      description: optional_child_optional_content(node, NODE_DESCRIPTION),
445      label: optional_attribute(node, ATTR_LABEL),
446      extension_elements: self.parse_extension_elements(node),
447      extension_attributes: self.parse_extension_attributes(node),
448      name: required_name(node)?,
449      feel_name: required_feel_name(node)?,
450      type_ref: optional_attribute(node, ATTR_TYPE_REF).unwrap_or(FEEL_TYPE_NAME_ANY.to_string()),
451      feel_type: None,
452    })
453  }
454
455  /// Creates a new [InformationItem] element populated with name.
456  fn create_information_item(&self, name: String, feel_name: Name) -> Result<InformationItem> {
457    Ok(InformationItem {
458      namespace: self.namespace.clone(),
459      model_name: self.model_name.clone(),
460      id: DmnId::Generated(gen_id()),
461      description: None,
462      label: None,
463      extension_elements: vec![],
464      extension_attributes: vec![],
465      name,
466      feel_name,
467      type_ref: FEEL_TYPE_NAME_ANY.to_string(),
468      feel_type: None,
469    })
470  }
471
472  /// Parses information requirements.
473  fn parse_information_requirements(&mut self, node: &Node, child_name: &str) -> Result<Vec<InformationRequirement>> {
474    let mut information_requirement_items = vec![];
475    for child_node in node.children().filter(name_eq(child_name)) {
476      information_requirement_items.push(self.parse_information_requirement(&child_node)?);
477    }
478    Ok(information_requirement_items)
479  }
480
481  /// Parses single information requirement.
482  fn parse_information_requirement(&mut self, node: &Node) -> Result<InformationRequirement> {
483    let req = InformationRequirement {
484      namespace: self.namespace.clone(),
485      model_name: self.model_name.clone(),
486      id: optional_id(node),
487      description: optional_child_optional_content(node, NODE_DESCRIPTION),
488      label: optional_attribute(node, ATTR_LABEL),
489      extension_elements: self.parse_extension_elements(node),
490      extension_attributes: self.parse_extension_attributes(node),
491      required_decision: optional_child_required_href(node, NODE_REQUIRED_DECISION)?,
492      required_input: optional_child_required_href(node, NODE_REQUIRED_INPUT)?,
493    };
494    Ok(req)
495  }
496
497  /// Parses knowledge requirements.
498  fn parse_knowledge_requirements(&mut self, node: &Node, child_name: &str) -> Result<Vec<KnowledgeRequirement>> {
499    let mut knowledge_requirement_items = vec![];
500    for child_node in node.children().filter(name_eq(child_name)) {
501      knowledge_requirement_items.push(self.parse_knowledge_requirement(&child_node)?);
502    }
503    Ok(knowledge_requirement_items)
504  }
505
506  /// Parses single knowledge requirement.
507  fn parse_knowledge_requirement(&mut self, node: &Node) -> Result<KnowledgeRequirement> {
508    let req = KnowledgeRequirement {
509      namespace: self.namespace.clone(),
510      model_name: self.model_name.clone(),
511      id: optional_id(node),
512      description: optional_child_optional_content(node, NODE_DESCRIPTION),
513      label: optional_attribute(node, ATTR_LABEL),
514      extension_elements: self.parse_extension_elements(node),
515      extension_attributes: self.parse_extension_attributes(node),
516      required_knowledge: required_child_required_href(node, NODE_REQUIRED_KNOWLEDGE)?,
517    };
518    Ok(req)
519  }
520
521  /// Parses authority requirements.
522  fn parse_authority_requirements(&mut self, node: &Node, child_name: &str) -> Result<Vec<AuthorityRequirement>> {
523    let mut authority_requirement_items = vec![];
524    for child_node in node.children().filter(name_eq(child_name)) {
525      authority_requirement_items.push(self.parse_authority_requirement(&child_node)?);
526    }
527    Ok(authority_requirement_items)
528  }
529
530  /// Parses single authority requirement.
531  fn parse_authority_requirement(&mut self, node: &Node) -> Result<AuthorityRequirement> {
532    let req = AuthorityRequirement {
533      namespace: self.namespace.clone(),
534      model_name: self.model_name.clone(),
535      id: optional_id(node),
536      description: optional_child_optional_content(node, NODE_DESCRIPTION),
537      label: optional_attribute(node, ATTR_LABEL),
538      extension_elements: self.parse_extension_elements(node),
539      extension_attributes: self.parse_extension_attributes(node),
540      required_authority: optional_child_required_href(node, NODE_REQUIRED_AUTHORITY)?,
541      required_decision: optional_child_required_href(node, NODE_REQUIRED_DECISION)?,
542      required_input: optional_child_required_href(node, NODE_REQUIRED_INPUT)?,
543    };
544    Ok(req)
545  }
546
547  fn parse_required_child_expression_instance(&self, node: &Node) -> Result<ExpressionInstance> {
548    self.parse_optional_child_expression_instance(node)?.ok_or_else(err_required_expression_instance_is_missing)
549  }
550
551  fn parse_optional_child_expression_instance(&self, node: &Node) -> Result<Option<ExpressionInstance>> {
552    if let Some(context) = self.parse_optional_context(node)? {
553      return Ok(Some(ExpressionInstance::Context(Box::new(context))));
554    }
555    if let Some(decision_table) = self.parse_optional_decision_table(node)? {
556      return Ok(Some(ExpressionInstance::DecisionTable(Box::new(decision_table))));
557    }
558    if let Some(function_definition) = self.parse_optional_function_definition(node)? {
559      return Ok(Some(ExpressionInstance::FunctionDefinition(Box::new(function_definition))));
560    }
561    if let Some(invocation) = self.parse_optional_invocation(node)? {
562      return Ok(Some(ExpressionInstance::Invocation(Box::new(invocation))));
563    }
564    if let Some(list) = self.parse_optional_list(node)? {
565      return Ok(Some(ExpressionInstance::List(Box::new(list))));
566    }
567    if let Some(literal_expression) = self.parse_optional_literal_expression(node) {
568      return Ok(Some(ExpressionInstance::LiteralExpression(Box::new(literal_expression))));
569    }
570    if let Some(relation) = self.parse_optional_relation(node)? {
571      return Ok(Some(ExpressionInstance::Relation(Box::new(relation))));
572    }
573    if let Some(conditional) = self.parse_optional_conditional(node)? {
574      return Ok(Some(ExpressionInstance::Conditional(Box::new(conditional))));
575    }
576    if let Some(filter) = self.parse_optional_filter(node)? {
577      return Ok(Some(ExpressionInstance::Filter(Box::new(filter))));
578    }
579    if let Some(r#for) = self.parse_optional_for(node)? {
580      return Ok(Some(ExpressionInstance::For(Box::new(r#for))));
581    }
582    if let Some(every) = self.parse_optional_every(node)? {
583      return Ok(Some(ExpressionInstance::Every(Box::new(every))));
584    }
585    if let Some(some) = self.parse_optional_some(node)? {
586      return Ok(Some(ExpressionInstance::Some(Box::new(some))));
587    }
588    Ok(None)
589  }
590
591  fn parse_required_expression_instance(&self, node: &Node) -> Result<ExpressionInstance> {
592    match node.tag_name().name() {
593      NODE_CONTEXT => {
594        let context = self.parse_context(node)?;
595        Ok(ExpressionInstance::Context(Box::new(context)))
596      }
597      NODE_DECISION_TABLE => {
598        let decision_table = self.parse_decision_table(node)?;
599        Ok(ExpressionInstance::DecisionTable(Box::new(decision_table)))
600      }
601      NODE_FUNCTION_DEFINITION => {
602        let function_definition = self.parse_function_definition(node)?;
603        Ok(ExpressionInstance::FunctionDefinition(Box::new(function_definition)))
604      }
605      NODE_INVOCATION => {
606        let invocation = self.parse_invocation(node)?;
607        Ok(ExpressionInstance::Invocation(Box::new(invocation)))
608      }
609      NODE_LIST => {
610        let list = self.parse_list(node)?;
611        Ok(ExpressionInstance::List(Box::new(list)))
612      }
613      NODE_LITERAL_EXPRESSION => {
614        let literal_expression = self.parse_literal_expression(node);
615        Ok(ExpressionInstance::LiteralExpression(Box::new(literal_expression)))
616      }
617      NODE_RELATION => {
618        let relation = self.parse_relation(node)?;
619        Ok(ExpressionInstance::Relation(Box::new(relation)))
620      }
621      NODE_CONDITIONAL => {
622        let conditional = self.parse_conditional(node)?;
623        Ok(ExpressionInstance::Conditional(Box::new(conditional)))
624      }
625      _ => Err(err_required_expression_instance_is_missing()),
626    }
627  }
628
629  fn parse_optional_decision_table(&self, node: &Node) -> Result<Option<DecisionTable>> {
630    if let Some(ref child_node) = node.children().find(name_eq(NODE_DECISION_TABLE)) {
631      return Ok(Some(self.parse_decision_table(child_node)?));
632    }
633    Ok(None)
634  }
635
636  fn parse_decision_table(&self, node: &Node) -> Result<DecisionTable> {
637    Ok(DecisionTable {
638      namespace: self.namespace.clone(),
639      model_name: self.model_name.clone(),
640      id: optional_id(node),
641      description: optional_child_optional_content(node, NODE_DESCRIPTION),
642      label: optional_attribute(node, ATTR_LABEL),
643      extension_elements: self.parse_extension_elements(node),
644      extension_attributes: self.parse_extension_attributes(node),
645      type_ref: optional_attribute(node, ATTR_TYPE_REF),
646      information_item_name: None,
647      input_clauses: self.parse_decision_table_inputs(node)?,
648      output_clauses: self.parse_decision_table_outputs(node)?,
649      annotations: vec![], // TODO implement parsing annotations
650      rules: self.parse_decision_table_rules(node)?,
651      hit_policy: self.parse_hit_policy_attribute(node)?,
652      aggregation: None,
653      preferred_orientation: self.parse_preferred_orientation_attribute(node)?,
654      output_label: optional_attribute(node, ATTR_OUTPUT_LABEL),
655    })
656  }
657
658  fn parse_decision_table_inputs(&self, node: &Node) -> Result<Vec<InputClause>> {
659    let mut input_clauses = vec![];
660    for ref child_node in node.children().filter(name_eq(NODE_INPUT)) {
661      input_clauses.push(self.parse_decision_table_input(child_node)?);
662    }
663    Ok(input_clauses)
664  }
665
666  fn parse_decision_table_input(&self, node: &Node) -> Result<InputClause> {
667    let input_expression = if let Ok(ref child_node) = required_child(node, NODE_INPUT_EXPRESSION) {
668      req_child_req_content(child_node, NODE_TEXT)?
669    } else {
670      return Err(err_required_input_expression_is_missing());
671    };
672    let input_values = if let Some(ref child_node) = optional_child(node, NODE_INPUT_VALUES) {
673      optional_child_required_content(child_node, NODE_TEXT)?
674    } else {
675      None
676    };
677    Ok(InputClause {
678      input_expression,
679      allowed_input_values: input_values,
680    })
681  }
682
683  fn parse_decision_table_outputs(&self, node: &Node) -> Result<Vec<OutputClause>> {
684    let mut output_clauses = vec![];
685    for ref child_node in node.children().filter(name_eq(NODE_OUTPUT)) {
686      output_clauses.push(self.parse_decision_table_output(child_node)?);
687    }
688    Ok(output_clauses)
689  }
690
691  fn parse_decision_table_output(&self, node: &Node) -> Result<OutputClause> {
692    let output_values = if let Some(ref child_node) = optional_child(node, NODE_OUTPUT_VALUES) {
693      optional_child_required_content(child_node, NODE_TEXT)?
694    } else {
695      None
696    };
697    let default_output_entry = if let Some(ref child_node) = optional_child(node, NODE_DEFAULT_OUTPUT_ENTRY) {
698      optional_child_required_content(child_node, NODE_TEXT)?
699    } else {
700      None
701    };
702    Ok(OutputClause {
703      type_ref: optional_attribute(node, ATTR_TYPE_REF),
704      name: optional_attribute(node, ATTR_NAME),
705      allowed_output_values: output_values,
706      default_output_entry,
707    })
708  }
709
710  fn parse_decision_table_rules(&self, node: &Node) -> Result<Vec<DecisionRule>> {
711    let mut rules = vec![];
712    for ref child_node in node.children().filter(name_eq(NODE_RULE)) {
713      rules.push(self.parse_decision_table_rule(child_node)?);
714    }
715    Ok(rules)
716  }
717
718  fn parse_decision_table_rule(&self, node: &Node) -> Result<DecisionRule> {
719    Ok(DecisionRule {
720      input_entries: self.parse_decision_table_input_entries(node)?,
721      output_entries: self.parse_decision_table_output_entries(node)?,
722      annotation_entries: vec![],
723    })
724  }
725
726  fn parse_decision_table_input_entries(&self, node: &Node) -> Result<Vec<InputEntry>> {
727    let mut input_entries = vec![];
728    for ref child_node in node.children().filter(name_eq(NODE_INPUT_ENTRY)) {
729      input_entries.push(self.parse_decision_table_input_entry(child_node)?);
730    }
731    Ok(input_entries)
732  }
733
734  /// Parses the content of the input entry in decision table.
735  ///
736  /// The content of the input entry is placed in `text` element which is required,
737  /// but the string inside this element may be empty. Some tools, like Camunda,
738  /// generate decision tables with empty string here, although in the graphical
739  /// interface there is `-` character representing FEEL `irrelevant` operator.
740  ///
741  /// So, long story short, when the string in `text` element is empty,
742  /// it is replaced by `irrelevant` operator.
743  fn parse_decision_table_input_entry(&self, node: &Node) -> Result<InputEntry> {
744    Ok(InputEntry {
745      text: req_child_opt_content(node, NODE_TEXT)?.unwrap_or("-".to_string()),
746    })
747  }
748
749  fn parse_decision_table_output_entries(&self, node: &Node) -> Result<Vec<OutputEntry>> {
750    let mut output_entries = vec![];
751    for ref child_node in node.children().filter(name_eq(NODE_OUTPUT_ENTRY)) {
752      output_entries.push(self.parse_decision_table_output_entry(child_node)?);
753    }
754    Ok(output_entries)
755  }
756
757  fn parse_decision_table_output_entry(&self, node: &Node) -> Result<OutputEntry> {
758    Ok(OutputEntry {
759      text: req_child_req_content(node, NODE_TEXT)?,
760    })
761  }
762
763  fn parse_optional_context(&self, node: &Node) -> Result<Option<Context>> {
764    if let Some(ref child_node) = node.children().find(name_eq(NODE_CONTEXT)) {
765      return Ok(Some(self.parse_context(child_node)?));
766    }
767    Ok(None)
768  }
769
770  fn parse_context(&self, node: &Node) -> Result<Context> {
771    Ok(Context {
772      namespace: self.namespace.clone(),
773      model_name: self.model_name.clone(),
774      id: optional_id(node),
775      description: optional_child_optional_content(node, NODE_DESCRIPTION),
776      label: optional_attribute(node, ATTR_LABEL),
777      extension_elements: self.parse_extension_elements(node),
778      extension_attributes: self.parse_extension_attributes(node),
779      type_ref: optional_attribute(node, ATTR_TYPE_REF),
780      context_entries: self.parse_context_entries(node)?,
781    })
782  }
783
784  fn parse_context_entries(&self, node: &Node) -> Result<Vec<ContextEntry>> {
785    let mut context_entries = vec![];
786    for ref child_node in node.children().filter(name_eq(NODE_CONTEXT_ENTRY)) {
787      context_entries.push(ContextEntry {
788        variable: self.parse_opt_information_item_child(child_node, NODE_VARIABLE)?,
789        value: self.parse_required_child_expression_instance(child_node)?,
790      });
791    }
792    Ok(context_entries)
793  }
794
795  fn parse_optional_invocation(&self, node: &Node) -> Result<Option<Invocation>> {
796    if let Some(ref child_node) = node.children().find(name_eq(NODE_INVOCATION)) {
797      return Ok(Some(self.parse_invocation(child_node)?));
798    }
799    Ok(None)
800  }
801
802  fn parse_invocation(&self, node: &Node) -> Result<Invocation> {
803    Ok(Invocation {
804      namespace: self.namespace.clone(),
805      model_name: self.model_name.clone(),
806      id: optional_id(node),
807      description: optional_child_optional_content(node, NODE_DESCRIPTION),
808      label: optional_attribute(node, ATTR_LABEL),
809      extension_elements: self.parse_extension_elements(node),
810      extension_attributes: self.parse_extension_attributes(node),
811      type_ref: optional_attribute(node, ATTR_TYPE_REF),
812      called_function: self.parse_required_child_expression_instance(node)?,
813      bindings: self.parse_bindings(node)?,
814    })
815  }
816
817  fn parse_bindings(&self, node: &Node) -> Result<Vec<Binding>> {
818    let mut bindings = vec![];
819    for ref child_node in node.children().filter(name_eq(NODE_BINDING)) {
820      bindings.push(Binding {
821        parameter: self.parse_req_information_item_child(child_node, NODE_PARAMETER)?,
822        binding_formula: self.parse_optional_child_expression_instance(child_node)?,
823      });
824    }
825    Ok(bindings)
826  }
827
828  /// Searches for the first node named 'list' among children of the specified `node`.
829  /// When such node is found, then parses a list and returns it, otherwise returns [None].
830  fn parse_optional_list(&self, node: &Node) -> Result<Option<List>> {
831    if let Some(ref child_node) = node.children().find(name_eq(NODE_LIST)) {
832      return Ok(Some(self.parse_list(child_node)?));
833    }
834    Ok(None)
835  }
836
837  /// Parses [List] directly from the specified node.
838  fn parse_list(&self, node: &Node) -> Result<List> {
839    let mut elements = vec![];
840    for child_node in node.children().filter(|n| {
841      let name = n.tag_name().name();
842      matches!(
843        name,
844        NODE_CONTEXT | NODE_DECISION_TABLE | NODE_FUNCTION_DEFINITION | NODE_INVOCATION | NODE_LIST | NODE_LITERAL_EXPRESSION | NODE_RELATION
845      )
846    }) {
847      elements.push(self.parse_required_expression_instance(&child_node)?);
848    }
849    Ok(List {
850      namespace: self.namespace.clone(),
851      model_name: self.model_name.clone(),
852      id: optional_id(node),
853      description: optional_child_optional_content(node, NODE_DESCRIPTION),
854      label: optional_attribute(node, ATTR_LABEL),
855      extension_elements: self.parse_extension_elements(node),
856      extension_attributes: self.parse_extension_attributes(node),
857      type_ref: optional_attribute(node, ATTR_TYPE_REF),
858      elements,
859    })
860  }
861
862  /// Searches for the first node named 'literalExpression' among children of the specified `node`.
863  /// When such node is found, then parses literal expression and returns it, otherwise returns [None].
864  fn parse_optional_literal_expression(&self, node: &Node) -> Option<LiteralExpression> {
865    if let Some(ref child_node) = node.children().find(name_eq(NODE_LITERAL_EXPRESSION)) {
866      return Some(self.parse_literal_expression(child_node));
867    }
868    None
869  }
870
871  /// Parses [LiteralExpression] directly from the specified node.
872  /// The `literal_expression_node` must be a node named `literalExpression`.
873  fn parse_literal_expression(&self, node: &Node) -> LiteralExpression {
874    LiteralExpression {
875      namespace: self.namespace.clone(),
876      model_name: self.model_name.clone(),
877      id: optional_id(node),
878      description: optional_child_optional_content(node, NODE_DESCRIPTION),
879      label: optional_attribute(node, ATTR_LABEL),
880      extension_elements: self.parse_extension_elements(node),
881      extension_attributes: self.parse_extension_attributes(node),
882      type_ref: optional_attribute(node, ATTR_TYPE_REF),
883      text: optional_child_optional_content(node, NODE_TEXT),
884      expression_language: optional_attribute(node, ATTR_EXPRESSION_LANGUAGE),
885      imported_values: None,
886    }
887  }
888
889  fn parse_optional_relation(&self, node: &Node) -> Result<Option<Relation>> {
890    if let Some(ref child_node) = node.children().find(name_eq(NODE_RELATION)) {
891      return Ok(Some(self.parse_relation(child_node)?));
892    }
893    Ok(None)
894  }
895
896  fn parse_relation(&self, node: &Node) -> Result<Relation> {
897    let mut columns = vec![];
898    for ref column_node in node.children().filter(name_eq(NODE_COLUMN)) {
899      columns.push(self.parse_information_item(column_node)?);
900    }
901    let mut rows = vec![];
902    for ref row_node in node.children().filter(name_eq(NODE_ROW)) {
903      let mut elements = vec![];
904      for ref expression_instance_node in row_node.children() {
905        if expression_instance_node.tag_name().name() == NODE_LITERAL_EXPRESSION {
906          let literal_expression = self.parse_literal_expression(expression_instance_node);
907          elements.push(ExpressionInstance::LiteralExpression(Box::new(literal_expression)));
908        }
909      }
910      if elements.len() != columns.len() {
911        return Err(err_number_of_elements_in_row_differs_from_number_of_columns());
912      }
913      rows.push(List {
914        namespace: self.namespace.clone(),
915        model_name: self.model_name.clone(),
916        id: optional_id(row_node),
917        description: optional_child_optional_content(row_node, NODE_DESCRIPTION),
918        label: optional_attribute(row_node, ATTR_LABEL),
919        extension_elements: self.parse_extension_elements(row_node),
920        extension_attributes: self.parse_extension_attributes(row_node),
921        type_ref: optional_attribute(row_node, ATTR_TYPE_REF),
922        elements,
923      });
924    }
925    Ok(Relation {
926      namespace: self.namespace.clone(),
927      model_name: self.model_name.clone(),
928      id: optional_id(node),
929      description: optional_child_optional_content(node, NODE_DESCRIPTION),
930      label: optional_attribute(node, ATTR_LABEL),
931      extension_elements: self.parse_extension_elements(node),
932      extension_attributes: self.parse_extension_attributes(node),
933      type_ref: optional_attribute(node, ATTR_TYPE_REF),
934      rows,
935      columns,
936    })
937  }
938
939  fn parse_optional_conditional(&self, node: &Node) -> Result<Option<Conditional>> {
940    if let Some(ref child_node) = node.children().find(name_eq(NODE_CONDITIONAL)) {
941      return Ok(Some(self.parse_conditional(child_node)?));
942    }
943    Ok(None)
944  }
945
946  fn parse_conditional(&self, node: &Node) -> Result<Conditional> {
947    let node_if = required_child(node, NODE_IF)?;
948    let node_then = required_child(node, NODE_THEN)?;
949    let node_else = required_child(node, NODE_ELSE)?;
950    Ok(Conditional {
951      namespace: self.namespace.clone(),
952      model_name: self.model_name.clone(),
953      id: optional_id(node),
954      description: optional_child_optional_content(node, NODE_DESCRIPTION),
955      label: optional_attribute(node, ATTR_LABEL),
956      extension_elements: self.parse_extension_elements(node),
957      extension_attributes: self.parse_extension_attributes(node),
958      type_ref: optional_attribute(node, ATTR_TYPE_REF),
959      if_expression: self.parse_required_child_expression(&node_if)?,
960      then_expression: self.parse_required_child_expression(&node_then)?,
961      else_expression: self.parse_required_child_expression(&node_else)?,
962    })
963  }
964
965  fn parse_optional_filter(&self, node: &Node) -> Result<Option<Filter>> {
966    if let Some(ref child_node) = node.children().find(name_eq(NODE_FILTER)) {
967      return Ok(Some(self.parse_filter(child_node)?));
968    }
969    Ok(None)
970  }
971
972  fn parse_filter(&self, node: &Node) -> Result<Filter> {
973    let node_in = required_child(node, NODE_IN)?;
974    let node_match = required_child(node, NODE_MATCH)?;
975    Ok(Filter {
976      namespace: self.namespace.clone(),
977      model_name: self.model_name.clone(),
978      id: optional_id(node),
979      description: optional_child_optional_content(node, NODE_DESCRIPTION),
980      label: optional_attribute(node, ATTR_LABEL),
981      extension_elements: self.parse_extension_elements(node),
982      extension_attributes: self.parse_extension_attributes(node),
983      type_ref: optional_attribute(node, ATTR_TYPE_REF),
984      in_expression: self.parse_required_child_expression(&node_in)?,
985      match_expression: self.parse_required_child_expression(&node_match)?,
986    })
987  }
988
989  fn parse_optional_for(&self, node: &Node) -> Result<Option<For>> {
990    if let Some(ref child_node) = node.children().find(name_eq(NODE_FOR)) {
991      return Ok(Some(self.parse_for(child_node)?));
992    }
993    Ok(None)
994  }
995
996  fn parse_for(&self, node: &Node) -> Result<For> {
997    let node_in = required_child(node, NODE_IN)?;
998    let node_return = required_child(node, NODE_RETURN)?;
999    Ok(For {
1000      namespace: self.namespace.clone(),
1001      model_name: self.model_name.clone(),
1002      id: optional_id(node),
1003      description: optional_child_optional_content(node, NODE_DESCRIPTION),
1004      label: optional_attribute(node, ATTR_LABEL),
1005      extension_elements: self.parse_extension_elements(node),
1006      extension_attributes: self.parse_extension_attributes(node),
1007      type_ref: optional_attribute(node, ATTR_TYPE_REF),
1008      iterator_variable: required_attribute(node, ATTR_ITERATOR_VARIABLE)?,
1009      in_expression: self.parse_required_typed_child_expression(&node_in)?,
1010      return_expression: self.parse_required_child_expression(&node_return)?,
1011    })
1012  }
1013
1014  fn parse_optional_every(&self, node: &Node) -> Result<Option<Every>> {
1015    if let Some(ref child_node) = node.children().find(name_eq(NODE_EVERY)) {
1016      return Ok(Some(self.parse_every(child_node)?));
1017    }
1018    Ok(None)
1019  }
1020
1021  fn parse_every(&self, node: &Node) -> Result<Every> {
1022    let node_in = required_child(node, NODE_IN)?;
1023    let node_satisfies = required_child(node, NODE_SATISFIES)?;
1024    Ok(Every {
1025      namespace: self.namespace.clone(),
1026      model_name: self.model_name.clone(),
1027      id: optional_id(node),
1028      description: optional_child_optional_content(node, NODE_DESCRIPTION),
1029      label: optional_attribute(node, ATTR_LABEL),
1030      extension_elements: self.parse_extension_elements(node),
1031      extension_attributes: self.parse_extension_attributes(node),
1032      type_ref: optional_attribute(node, ATTR_TYPE_REF),
1033      iterator_variable: required_attribute(node, ATTR_ITERATOR_VARIABLE)?,
1034      in_expression: self.parse_required_typed_child_expression(&node_in)?,
1035      satisfies_expression: self.parse_required_child_expression(&node_satisfies)?,
1036    })
1037  }
1038
1039  fn parse_optional_some(&self, node: &Node) -> Result<Option<Some>> {
1040    if let Some(ref child_node) = node.children().find(name_eq(NODE_SOME)) {
1041      return Ok(Some(self.parse_some(child_node)?));
1042    }
1043    Ok(None)
1044  }
1045
1046  fn parse_some(&self, node: &Node) -> Result<Some> {
1047    let node_in = required_child(node, NODE_IN)?;
1048    let node_satisfies = required_child(node, NODE_SATISFIES)?;
1049    Ok(Some {
1050      namespace: self.namespace.clone(),
1051      model_name: self.model_name.clone(),
1052      id: optional_id(node),
1053      description: optional_child_optional_content(node, NODE_DESCRIPTION),
1054      label: optional_attribute(node, ATTR_LABEL),
1055      extension_elements: self.parse_extension_elements(node),
1056      extension_attributes: self.parse_extension_attributes(node),
1057      type_ref: optional_attribute(node, ATTR_TYPE_REF),
1058      iterator_variable: required_attribute(node, ATTR_ITERATOR_VARIABLE)?,
1059      in_expression: self.parse_required_typed_child_expression(&node_in)?,
1060      satisfies_expression: self.parse_required_child_expression(&node_satisfies)?,
1061    })
1062  }
1063
1064  fn parse_required_child_expression(&self, node: &Node) -> Result<ChildExpression> {
1065    let child_node = first_child_element(node)?;
1066    Ok(ChildExpression {
1067      id: optional_id(node),
1068      value: self.parse_required_expression_instance(&child_node)?,
1069    })
1070  }
1071
1072  fn parse_required_typed_child_expression(&self, node: &Node) -> Result<TypedChildExpression> {
1073    let child_node = first_child_element(node)?;
1074    Ok(TypedChildExpression {
1075      id: optional_id(node),
1076      value: self.parse_required_expression_instance(&child_node)?,
1077      type_ref: optional_attribute(node, ATTR_TYPE_REF),
1078    })
1079  }
1080
1081  /// Parses extension elements.
1082  fn parse_extension_elements(&self, _node: &Node) -> Vec<ExtensionElement> {
1083    // Currently ignored. Ready for future development when needed.
1084    vec![]
1085  }
1086
1087  /// Parses extension attributes.
1088  fn parse_extension_attributes(&self, _node: &Node) -> Vec<ExtensionAttribute> {
1089    // Currently ignored. Ready for future development when needed.
1090    vec![]
1091  }
1092
1093  /// Returns boolean value of the specified attribute.
1094  fn parse_boolean_attribute(&self, node: &Node, attr_name: &str, default_value: bool) -> bool {
1095    if let Some(attr_value) = node.attribute(attr_name) {
1096      attr_value == "true"
1097    } else {
1098      default_value
1099    }
1100  }
1101
1102  /// Returns the value of the hit policy attribute.
1103  fn parse_hit_policy_attribute(&self, node: &Node) -> Result<HitPolicy> {
1104    if let Some(hit_policy_text) = node.attribute(ATTR_HIT_POLICY) {
1105      match hit_policy_text.trim() {
1106        "UNIQUE" => Ok(HitPolicy::Unique),
1107        "ANY" => Ok(HitPolicy::Any),
1108        "PRIORITY" => Ok(HitPolicy::Priority),
1109        "FIRST" => Ok(HitPolicy::First),
1110        "RULE ORDER" => Ok(HitPolicy::RuleOrder),
1111        "OUTPUT ORDER" => Ok(HitPolicy::OutputOrder),
1112        "COLLECT" => Ok(HitPolicy::Collect(self.parse_aggregation_attribute(node)?)),
1113        other => Err(err_invalid_hit_policy(other)),
1114      }
1115    } else {
1116      Ok(HitPolicy::Unique)
1117    }
1118  }
1119
1120  /// Returns the value of the aggregation attribute.
1121  fn parse_aggregation_attribute(&self, node: &Node) -> Result<BuiltinAggregator> {
1122    if let Some(aggregation_text) = node.attribute(ATTR_AGGREGATION) {
1123      match aggregation_text.trim() {
1124        "COUNT" => Ok(BuiltinAggregator::Count),
1125        "SUM" => Ok(BuiltinAggregator::Sum),
1126        "MIN" => Ok(BuiltinAggregator::Min),
1127        "MAX" => Ok(BuiltinAggregator::Max),
1128        other => Err(err_invalid_aggregation(other)),
1129      }
1130    } else {
1131      Ok(BuiltinAggregator::List)
1132    }
1133  }
1134
1135  /// Returns the value of the preferred decision table orientation attribute.
1136  fn parse_preferred_orientation_attribute(&self, node: &Node) -> Result<DecisionTableOrientation> {
1137    if let Some(attr_value) = node.attribute(ATTR_PREFERRED_ORIENTATION) {
1138      DecisionTableOrientation::try_from(attr_value)
1139    } else {
1140      Ok(DecisionTableOrientation::RuleAsRow)
1141    }
1142  }
1143
1144  /// Parse DMNDI part of the diagram definitions.
1145  fn parse_dmndi(&self, node: &Node) -> Result<Option<Dmndi>> {
1146    if let Some(child_node) = node.children().find(name_eq(NODE_DMNDI)) {
1147      let dmndi = Dmndi {
1148        styles: self.parse_styles(&child_node)?,
1149        diagrams: self.parse_diagrams(&child_node)?,
1150      };
1151      return Ok(Some(dmndi));
1152    }
1153    Ok(None)
1154  }
1155
1156  /// Parses shared styles defined in diagram.
1157  fn parse_styles(&self, node: &Node) -> Result<Vec<DmnStyle>> {
1158    let mut styles = vec![];
1159    for child_node in node.children().filter(name_eq(NODE_DMNDI_STYLE)) {
1160      styles.push(self.parse_style(&child_node)?);
1161    }
1162    Ok(styles)
1163  }
1164
1165  /// Parses single style.
1166  fn parse_style(&self, node: &Node) -> Result<DmnStyle> {
1167    Ok(DmnStyle {
1168      id: required_attribute(node, ATTR_ID)?,
1169      fill_color: self.parse_optional_color(node, NODE_DMNDI_FILL_COLOR)?,
1170      stroke_color: self.parse_optional_color(node, NODE_DMNDI_STROKE_COLOR)?,
1171      font_color: self.parse_optional_color(node, NODE_DMNDI_FONT_COLOR)?,
1172      font_family: optional_attribute(node, ATTR_FONT_FAMILY),
1173      font_size: optional_double(node, ATTR_FONT_SIZE),
1174      font_italic: optional_bool(node, ATTR_FONT_ITALIC),
1175      font_bold: optional_bool(node, ATTR_FONT_BOLD),
1176      font_underline: optional_bool(node, ATTR_FONT_UNDERLINE),
1177      font_strike_through: optional_bool(node, ATTR_FONT_STRIKE_THROUGH),
1178      label_horizontal_alignment: self.parse_alignment_kind(node, NODE_DMNDI_LABEL_HORIZONTAL_ALIGNMENT),
1179      label_vertical_alignment: self.parse_alignment_kind(node, NODE_DMNDI_LABEL_VERTICAL_ALIGNMENT),
1180    })
1181  }
1182
1183  /// Parses the color definition.
1184  fn parse_optional_color(&self, node: &Node, child_name: &str) -> Result<Option<DcColor>> {
1185    if let Some(color_node) = node.children().find(name_eq(child_name)) {
1186      Ok(Some(DcColor {
1187        red: required_color_part(&color_node, ATTR_RED)?,
1188        green: required_color_part(&color_node, ATTR_GREEN)?,
1189        blue: required_color_part(&color_node, ATTR_BLUE)?,
1190      }))
1191    } else {
1192      Ok(None)
1193    }
1194  }
1195
1196  /// Parses the alignment.
1197  fn parse_alignment_kind(&self, node: &Node, attr_name: &str) -> Option<DcAlignmentKind> {
1198    match node.attribute(attr_name) {
1199      Some("start") => Some(DcAlignmentKind::Start),
1200      Some("center") => Some(DcAlignmentKind::Center),
1201      Some("end") => Some(DcAlignmentKind::End),
1202      _ => None,
1203    }
1204  }
1205
1206  /// Parses diagrams defined in [Dmndi].
1207  fn parse_diagrams(&self, node: &Node) -> Result<Vec<DmnDiagram>> {
1208    let mut diagrams = vec![];
1209    for child_node in node.children().filter(name_eq(NODE_DMNDI_DMN_DIAGRAM)) {
1210      diagrams.push(self.parse_diagram(&child_node)?);
1211    }
1212    Ok(diagrams)
1213  }
1214
1215  /// Parses a single diagram.
1216  fn parse_diagram(&self, node: &Node) -> Result<DmnDiagram> {
1217    Ok(DmnDiagram {
1218      id: optional_attribute(node, ATTR_ID),
1219      name: optional_attribute(node, ATTR_NAME),
1220      documentation: "".to_string(),
1221      resolution: optional_double(node, ATTR_RESOLUTION).unwrap_or(300.0),
1222      diagram_elements: self.parse_diagram_elements(node)?,
1223      shared_style: optional_attribute(node, ATTR_SHARED_STYLE),
1224      local_style: None, //TODO Implement or remove when the official specification is ready.
1225      size: self.parse_dimension(node)?,
1226    })
1227  }
1228
1229  /// Parses dimension.
1230  fn parse_dimension(&self, size_node: &Node) -> Result<Option<DcDimension>> {
1231    if let Some(node) = size_node.children().find(name_eq(NODE_DMNDI_SIZE)) {
1232      Ok(Some(DcDimension {
1233        width: required_double(&node, ATTR_WIDTH)?,
1234        height: required_double(&node, ATTR_HEIGHT)?,
1235      }))
1236    } else {
1237      Ok(None)
1238    }
1239  }
1240
1241  /// Parses diagram elements
1242  fn parse_diagram_elements(&self, size_node: &Node) -> Result<Vec<DmnDiagramElement>> {
1243    let mut diagram_element = vec![];
1244    for child_node in size_node.children().filter(name_eq(NODE_DMNDI_DMN_SHAPE)) {
1245      diagram_element.push(self.parse_shape(&child_node)?);
1246    }
1247    for child_node in size_node.children().filter(name_eq(NODE_DMNDI_DMN_EDGE)) {
1248      diagram_element.push(self.parse_edge(&child_node)?);
1249    }
1250    Ok(diagram_element)
1251  }
1252
1253  /// Parses shape.
1254  fn parse_shape(&self, node: &Node) -> Result<DmnDiagramElement> {
1255    Ok(DmnDiagramElement::DmnShape(DmnShape {
1256      id: optional_attribute(node, ATTR_ID),
1257      bounds: self.parse_bounds(node)?,
1258      dmn_element_ref: optional_attribute(node, ATTR_DMN_ELEMENT_REF),
1259      is_listed_input_data: false,
1260      decision_service_divider_line: self.parse_divider_line(node)?,
1261      is_collapsed: optional_bool(node, ATTR_IS_COLLAPSED).unwrap_or(false),
1262      shared_style: optional_attribute(node, ATTR_SHARED_STYLE),
1263      local_style: None, //TODO Implement or remove when the official specification is ready.
1264      label: self.parse_label(node)?,
1265    }))
1266  }
1267
1268  /// Parses bounds.
1269  fn parse_bounds(&self, node: &Node) -> Result<DcBounds> {
1270    match self.parse_optional_bounds(node) {
1271      Ok(Some(n)) => Ok(n),
1272      _ => Err(err_required_child_node_is_missing(node.tag_name().name(), NODE_DMNDI_BOUNDS)),
1273    }
1274  }
1275
1276  /// Parses bounds.
1277  fn parse_optional_bounds(&self, node: &Node) -> Result<Option<DcBounds>> {
1278    if let Some(child_node) = node.children().find(name_eq(NODE_DMNDI_BOUNDS)) {
1279      Ok(Some(DcBounds {
1280        x: required_double(&child_node, ATTR_X)?,
1281        y: required_double(&child_node, ATTR_Y)?,
1282        width: required_double(&child_node, ATTR_WIDTH)?,
1283        height: required_double(&child_node, ATTR_HEIGHT)?,
1284      }))
1285    } else {
1286      Ok(None)
1287    }
1288  }
1289
1290  /// Parses divider line.
1291  fn parse_divider_line(&self, node: &Node) -> Result<Option<DmnDecisionServiceDividerLine>> {
1292    if let Some(child_node) = node.children().find(name_eq(NODE_DMNDI_DECISION_SERVICE_DIVIDER_LINE)) {
1293      Ok(Some(DmnDecisionServiceDividerLine {
1294        id: optional_attribute(&child_node, ATTR_ID),
1295        way_points: self.parse_way_points(&child_node)?,
1296        shared_style: optional_attribute(node, ATTR_SHARED_STYLE),
1297        local_style: None, //TODO Implement or remove when the official specification is ready.
1298      }))
1299    } else {
1300      Ok(None)
1301    }
1302  }
1303
1304  /// Parses edge.
1305  fn parse_edge(&self, node: &Node) -> Result<DmnDiagramElement> {
1306    Ok(DmnDiagramElement::DmnEdge(DmnEdge {
1307      id: optional_attribute(node, ATTR_ID),
1308      way_points: self.parse_way_points(node)?,
1309      dmn_element_ref: optional_attribute(node, ATTR_DMN_ELEMENT_REF),
1310      source_element: None,
1311      target_element: None,
1312      shared_style: optional_attribute(node, ATTR_SHARED_STYLE),
1313      local_style: None, //TODO Implement or remove when the official specification is ready.
1314      label: self.parse_label(node)?,
1315    }))
1316  }
1317
1318  /// Parses way points.
1319  fn parse_way_points(&self, node: &Node) -> Result<Vec<DcPoint>> {
1320    let mut way_points = vec![];
1321    for child_node in node.children().filter(name_eq(NODE_DMNDI_WAYPOINT)) {
1322      way_points.push(self.parse_point(&child_node)?)
1323    }
1324    Ok(way_points)
1325  }
1326
1327  /// Parses the point coordinates.
1328  fn parse_point(&self, node: &Node) -> Result<DcPoint> {
1329    Ok(DcPoint {
1330      x: required_double(node, ATTR_X)?,
1331      y: required_double(node, ATTR_Y)?,
1332    })
1333  }
1334
1335  /// Parses the label of the element.
1336  fn parse_label(&self, node: &Node) -> Result<Option<DmnLabel>> {
1337    if let Some(child_node) = node.children().find(name_eq(NODE_DMNDI_LABEL)) {
1338      Ok(Some(DmnLabel {
1339        bounds: self.parse_optional_bounds(&child_node)?,
1340        text: optional_child_optional_content(&child_node, ATTR_LABEL_TEXT),
1341        shared_style: optional_attribute(&child_node, ATTR_SHARED_STYLE),
1342      }))
1343    } else {
1344      Ok(None)
1345    }
1346  }
1347}
1348
1349/// Returns the first child element of the specified node.
1350fn first_child_element<'a>(node: &'a Node) -> Result<Node<'a, 'a>> {
1351  node
1352    .children()
1353    .filter(|n| matches!(n.node_type(), NodeType::Element))
1354    .take(1)
1355    .next()
1356    .ok_or(err_node_has_no_children(node.tag_name().name()))
1357}
1358
1359/// Returns required name attribute for specified node.
1360fn required_name(node: &Node) -> Result<String> {
1361  required_attribute(node, ATTR_NAME)
1362}
1363
1364/// Returns optional identifier provided in model or generates a new one.
1365fn optional_id(node: &Node) -> DmnId {
1366  optional_attribute(node, ATTR_ID).map(DmnId::Provided).unwrap_or(DmnId::Generated(gen_id()))
1367}
1368
1369/// Returns FEEL name for specified node.
1370fn required_feel_name(node: &Node) -> Result<Name> {
1371  let input = required_name(node)?;
1372  Ok(dsntk_feel_parser::parse_longest_name(&input).unwrap_or(input.into()))
1373}
1374
1375/// Returns the required `href` attribute.
1376pub fn required_href(node: &Node) -> Result<HRef> {
1377  HRef::try_from(required_attribute(node, ATTR_HREF)?.as_str())
1378}
1379
1380/// Returns the required URI attribute.
1381pub fn required_uri(node: &Node, attr_name: &str) -> Result<Uri> {
1382  to_uri(required_attribute(node, attr_name)?.as_str())
1383}
1384
1385/// Returns an optional URI attribute.
1386pub fn optional_uri(node: &Node, attr_name: &str) -> Result<Option<Uri>> {
1387  if let Some(value) = optional_attribute(node, attr_name) {
1388    Ok(Some(to_uri(value.as_str())?))
1389  } else {
1390    Ok(None)
1391  }
1392}
1393
1394/// Returns the required `href` attribute taken from required child node.
1395pub fn required_child_required_href(node: &Node, child_name: &str) -> Result<HRef> {
1396  let child_node = required_child(node, child_name)?;
1397  HRef::try_from(required_attribute(&child_node, ATTR_HREF)?.as_str())
1398}
1399
1400/// Returns the required `href` attribute of the optional child node.
1401pub fn optional_child_required_href(node: &Node, child_name: &str) -> Result<Option<HRef>> {
1402  if let Some(child_node) = optional_child(node, child_name) {
1403    Ok(Some(HRef::try_from(required_attribute(&child_node, ATTR_HREF)?.as_str())?))
1404  } else {
1405    Ok(None)
1406  }
1407}
1408
1409/// Returns required `href` attributes collected from optional child nodes.
1410pub fn optional_children_required_href(node: &Node, child_name: &str) -> Result<Vec<HRef>> {
1411  let mut hrefs = vec![];
1412  for ref child_node in node.children().filter(name_eq(child_name)) {
1413    hrefs.push(required_href(child_node)?);
1414  }
1415  Ok(hrefs)
1416}
dsntk_model/parser.rs

dsntk_model/
parser.rs
